// 获取全局应用实例
const app = getApp();
// 初始化云数据库
const db = wx.cloud.database();
// 获取量表配置集合引用
const testConfigCollection = db.collection('test_config');

Page({
  // 页面的初始数据
  data: {
    testType: '',       // 量表类型，如SAS、SDS
    testName: '',       // 量表名称
    config: {
      rawScoreMethod: '所有题得分之和',  // 原始分计算方法
      standardFactor: 1.25, // 标准分换算因子，默认为1.25倍
      mildThreshold: 50,    // 轻度阈值
      moderateThreshold: 60, // 中度阈值
      severeThreshold: 70    // 重度阈值
    }
  },

  // 页面加载时执行
  onLoad: function(options) {
    console.log('===== test-config/index 页面加载 =====');
    console.log('页面参数:', options);
    console.log('app.globalData:', app.globalData);
    console.log('本地存储:', {
      currentTestConfigType: wx.getStorageSync('currentTestConfigType')
    });
    
    // 从多个来源获取测试类型，优先级：URL参数 > 本地存储 > 全局变量
    let testType = null;
    
    // 1. 从URL参数获取
    if (options && options.type) {
      testType = options.type;
      console.log('从URL参数获取测试类型:', testType);
    } 
    // 2. 从本地存储获取
    else if (wx.getStorageSync('currentTestConfigType')) {
      testType = wx.getStorageSync('currentTestConfigType');
      console.log('从本地存储获取测试类型:', testType);
      
      // 使用完就删除，避免冲突
      wx.removeStorageSync('currentTestConfigType');
    } 
    // 3. 从全局变量获取
    else if (app.globalData && app.globalData.testConfigType) {
      testType = app.globalData.testConfigType;
      console.log('从全局变量获取测试类型:', testType);
      
      // 使用完就删除，避免冲突
      app.globalData.testConfigType = null;
    }
    
    // 检查是否成功获取测试类型
    if (!testType) {
      console.error('未获取到有效的量表类型参数');
      wx.showToast({
        title: '参数错误',
        icon: 'none'
      });
      // 延迟返回上一页
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
      return;
    }
    
    // 根据测试类型设置测试名称
    let testName = '';
    if (testType === 'SAS') {
      testName = '焦虑自评量表(SAS)';
    } else if (testType === 'SDS') {
      testName = '抑郁自评量表(SDS)';
    }

    console.log('设置页面数据 - 量表类型:', testType, '量表名称:', testName);
    this.setData({
      testType,
      testName
    });

    // 检查用户权限，只有工作人员可以访问
    const userInfo = wx.getStorageSync('userInfo');
    console.log('当前用户信息:', userInfo);
    
    // 验证用户是否有权限访问此页面
    if (!userInfo || userInfo.role !== 'staff') {
      console.warn('用户无权访问此页面:', userInfo ? userInfo.role : '未登录');
      wx.showToast({
        title: '您无权访问此页面',
        icon: 'none'
      });
      // 延迟返回上一页
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
      return;
    }

    // 加载该测试类型的现有配置
    console.log('准备加载配置数据');
    this.loadConfig(testType);
  },

  // 从数据库加载量表配置
  loadConfig: function(testType) {
    console.log('===== 开始加载配置 =====');
    wx.showLoading({
      title: '加载中',
    });

    // 检查数据库连接状态
    try {
      console.log('测试数据库连接');
      const testDb = db.command;
      console.log('数据库连接正常');
    } catch (error) {
      // 数据库连接异常处理
      console.error('数据库连接异常:', error);
      wx.hideLoading();
      wx.showToast({
        title: '数据库连接失败',
        icon: 'none'
      });
      return;
    }

    // 根据测试类型查询配置
    console.log('查询条件:', { testType: testType });
    testConfigCollection.where({
      testType: testType
    }).get().then(res => {
      wx.hideLoading();
      console.log('配置查询结果:', res);
      
      // 判断是否已有配置数据
      if (res.data && res.data.length > 0) {
        // 已有配置，加载现有配置
        const existingConfig = res.data[0];
        console.log('发现现有配置:', existingConfig);
        
        // 根据测试类型设置默认值
        let config = { ...this.data.config };
        if (testType === 'SDS') {
          // SDS量表默认阈值与SAS不同
          config = {
            ...config,
            mildThreshold: 53,
            moderateThreshold: 63,
            severeThreshold: 73
          };
        }
        
        // 合并数据库中的配置与默认配置
        console.log('合并后的配置:', {
          ...config,
          ...existingConfig
        });
        
        // 更新页面数据
        this.setData({
          config: {
            ...config,
            ...existingConfig
          }
        });
      } else {
        // 没有现有配置，使用默认值
        console.log('未找到现有配置，使用默认值');
        let config = { ...this.data.config };
        // 不同量表使用不同的默认阈值
        if (testType === 'SDS') {
          // SDS量表默认阈值与SAS不同
          config = {
            ...config,
            mildThreshold: 53,
            moderateThreshold: 63,
            severeThreshold: 73
          };
        }
        
        console.log('使用的默认配置:', config);
        this.setData({ config });
      }
    }).catch(err => {
      // 错误处理
      wx.hideLoading();
      console.error('加载配置失败', err);
      wx.showToast({
        title: '加载配置失败',
        icon: 'none'
      });
    });
  },

  // 处理标准分换算因子输入
  onStandardFactorInput: function(e) {
    const value = parseFloat(e.detail.value);
    // 验证输入值是否为正数
    if (!isNaN(value) && value > 0) {
      this.setData({
        'config.standardFactor': value
      });
    }
  },

  // 处理轻度阈值输入
  onMildThresholdInput: function(e) {
    const value = parseInt(e.detail.value);
    // 验证输入值是否有效（大于0且小于中度阈值）
    if (!isNaN(value) && value > 0 && value < this.data.config.moderateThreshold) {
      this.setData({
        'config.mildThreshold': value
      });
    }
  },

  // 处理中度阈值输入
  onModerateThresholdInput: function(e) {
    const value = parseInt(e.detail.value);
    // 验证输入值是否有效（大于轻度阈值且小于重度阈值）
    if (!isNaN(value) && value > this.data.config.mildThreshold && value < this.data.config.severeThreshold) {
      this.setData({
        'config.moderateThreshold': value
      });
    }
  },

  // 处理重度阈值输入
  onSevereThresholdInput: function(e) {
    const value = parseInt(e.detail.value);
    // 验证输入值是否有效（大于中度阈值）
    if (!isNaN(value) && value > this.data.config.moderateThreshold) {
      this.setData({
        'config.severeThreshold': value
      });
    }
  },

  // 保存配置到数据库
  saveConfig: function() {
    const { testType, config } = this.data;

    // 验证输入合法性，确保阈值递增
    if (config.mildThreshold >= config.moderateThreshold || 
        config.moderateThreshold >= config.severeThreshold) {
      wx.showToast({
        title: '阈值设置错误，请检查',
        icon: 'none'
      });
      return;
    }

    // 显示加载提示
    wx.showLoading({
      title: '保存中',
    });

    // 检查是否已有配置，决定是更新还是创建
    testConfigCollection.where({
      testType: testType
    }).get().then(res => {
      if (res.data && res.data.length > 0) {
        // 更新现有配置
        const configId = res.data[0]._id;
        return testConfigCollection.doc(configId).update({
          data: {
            standardFactor: config.standardFactor,
            mildThreshold: config.mildThreshold,
            moderateThreshold: config.moderateThreshold,
            severeThreshold: config.severeThreshold,
            updateTime: db.serverDate()  // 记录更新时间
          }
        });
      } else {
        // 创建新配置记录
        return testConfigCollection.add({
          data: {
            testType: testType,
            rawScoreMethod: config.rawScoreMethod,
            standardFactor: config.standardFactor,
            mildThreshold: config.mildThreshold,
            moderateThreshold: config.moderateThreshold,
            severeThreshold: config.severeThreshold,
            createTime: db.serverDate(),  // 记录创建时间
            updateTime: db.serverDate()   // 记录更新时间
          }
        });
      }
    }).then(() => {
      // 保存成功后的处理
      wx.hideLoading();
      wx.showToast({
        title: '保存成功',
      });
      
      // 短暂延迟后返回上一页
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
    }).catch(err => {
      // 保存失败的错误处理
      wx.hideLoading();
      console.error('保存配置失败', err);
      wx.showToast({
        title: '保存失败，请重试',
        icon: 'none'
      });
    });
  },

  // 返回上一页
  goBack: function() {
    console.log('返回按钮被点击');
    
    // 如果是通过redirectTo跳转来的，使用navigateTo回到原页面
    wx.navigateTo({
      url: '/pages/staff/test-management/index',
      fail: function(error) {
        // 主要跳转失败时的备用方案
        console.error('跳转回量表管理页面失败:', error);
        // 备用方案：返回到函数页面
        wx.switchTab({
          url: '/pages/function/function',
          fail: function(err) {
            // 所有跳转方式都失败的处理
            console.error('返回函数页面也失败:', err);
            wx.showToast({
              title: '返回失败',
              icon: 'none'
            });
          }
        });
      }
    });
  }
}); 